home *** CD-ROM | disk | FTP | other *** search
/ Chip 2007 January, February, March & April / Chip-Cover-CD-2007-02.iso / Pakiet bezpieczenstwa / mini Pentoo LiveCD 2006.1 / mpentoo-2006.1.iso / livecd.squashfs / usr / lib / python2.4 / socket.pyc (.txt) < prev    next >
Python Compiled Bytecode  |  2005-10-18  |  12KB  |  451 lines
  1. # Source Generated with Decompyle++
  2. # File: in.pyc (Python 2.4)
  3.  
  4. """This module provides socket operations and some related functions.
  5. On Unix, it supports IP (Internet Protocol) and Unix domain sockets.
  6. On other systems, it only supports IP. Functions specific for a
  7. socket are available as methods of the socket object.
  8.  
  9. Functions:
  10.  
  11. socket() -- create a new socket object
  12. socketpair() -- create a pair of new socket objects [*]
  13. fromfd() -- create a socket object from an open file descriptor [*]
  14. gethostname() -- return the current hostname
  15. gethostbyname() -- map a hostname to its IP number
  16. gethostbyaddr() -- map an IP number or hostname to DNS info
  17. getservbyname() -- map a service name and a protocol name to a port number
  18. getprotobyname() -- mape a protocol name (e.g. 'tcp') to a number
  19. ntohs(), ntohl() -- convert 16, 32 bit int from network to host byte order
  20. htons(), htonl() -- convert 16, 32 bit int from host to network byte order
  21. inet_aton() -- convert IP addr string (123.45.67.89) to 32-bit packed format
  22. inet_ntoa() -- convert 32-bit packed format IP to string (123.45.67.89)
  23. ssl() -- secure socket layer support (only available if configured)
  24. socket.getdefaulttimeout() -- get the default timeout value
  25. socket.setdefaulttimeout() -- set the default timeout value
  26.  
  27.  [*] not available on all platforms!
  28.  
  29. Special objects:
  30.  
  31. SocketType -- type object for socket objects
  32. error -- exception raised for I/O errors
  33. has_ipv6 -- boolean value indicating if IPv6 is supported
  34.  
  35. Integer constants:
  36.  
  37. AF_INET, AF_UNIX -- socket domains (first argument to socket() call)
  38. SOCK_STREAM, SOCK_DGRAM, SOCK_RAW -- socket types (second argument)
  39.  
  40. Many other constants may be defined; these may be used in calls to
  41. the setsockopt() and getsockopt() methods.
  42. """
  43. import _socket
  44. from _socket import *
  45. _have_ssl = False
  46.  
  47. try:
  48.     import _ssl
  49.     from _ssl import *
  50.     _have_ssl = True
  51. except ImportError:
  52.     pass
  53.  
  54. import os
  55. import sys
  56.  
  57. try:
  58.     from errno import EBADF
  59. except ImportError:
  60.     EBADF = 9
  61.  
  62. __all__ = [
  63.     'getfqdn']
  64. __all__.extend(os._get_exports_list(_socket))
  65. if _have_ssl:
  66.     __all__.extend(os._get_exports_list(_ssl))
  67.  
  68. _realsocket = socket
  69. if _have_ssl:
  70.     _realssl = ssl
  71.     
  72.     def ssl(sock, keyfile = None, certfile = None):
  73.         if hasattr(sock, '_sock'):
  74.             sock = sock._sock
  75.         
  76.         return _realssl(sock, keyfile, certfile)
  77.  
  78.  
  79. if sys.platform.lower().startswith('win'):
  80.     errorTab = { }
  81.     errorTab[10004] = 'The operation was interrupted.'
  82.     errorTab[10009] = 'A bad file handle was passed.'
  83.     errorTab[10013] = 'Permission denied.'
  84.     errorTab[10014] = 'A fault occurred on the network??'
  85.     errorTab[10022] = 'An invalid operation was attempted.'
  86.     errorTab[10035] = 'The socket operation would block'
  87.     errorTab[10036] = 'A blocking operation is already in progress.'
  88.     errorTab[10048] = 'The network address is in use.'
  89.     errorTab[10054] = 'The connection has been reset.'
  90.     errorTab[10058] = 'The network has been shut down.'
  91.     errorTab[10060] = 'The operation timed out.'
  92.     errorTab[10061] = 'Connection refused.'
  93.     errorTab[10063] = 'The name is too long.'
  94.     errorTab[10064] = 'The host is down.'
  95.     errorTab[10065] = 'The host is unreachable.'
  96.     __all__.append('errorTab')
  97.  
  98.  
  99. def getfqdn(name = ''):
  100.     '''Get fully qualified domain name from name.
  101.  
  102.     An empty argument is interpreted as meaning the local host.
  103.  
  104.     First the hostname returned by gethostbyaddr() is checked, then
  105.     possibly existing aliases. In case no FQDN is available, hostname
  106.     as returned by gethostname() is returned.
  107.     '''
  108.     name = name.strip()
  109.     if not name or name == '0.0.0.0':
  110.         name = gethostname()
  111.     
  112.     
  113.     try:
  114.         (hostname, aliases, ipaddrs) = gethostbyaddr(name)
  115.     except error:
  116.         pass
  117.  
  118.     aliases.insert(0, hostname)
  119.     for name in aliases:
  120.         if '.' in name:
  121.             break
  122.             continue
  123.     else:
  124.         name = hostname
  125.     return name
  126.  
  127. _socketmethods = ('bind', 'connect', 'connect_ex', 'fileno', 'listen', 'getpeername', 'getsockname', 'getsockopt', 'setsockopt', 'sendall', 'setblocking', 'settimeout', 'gettimeout', 'shutdown')
  128. if sys.platform == 'riscos':
  129.     _socketmethods = _socketmethods + ('sleeptaskw',)
  130.  
  131.  
  132. class _closedsocket(object):
  133.     __slots__ = []
  134.     
  135.     def _dummy(*args):
  136.         raise error(EBADF, 'Bad file descriptor')
  137.  
  138.     send = recv = sendto = recvfrom = __getattr__ = _dummy
  139.  
  140.  
  141. class _socketobject(object):
  142.     __doc__ = _realsocket.__doc__
  143.     __slots__ = [
  144.         '_sock',
  145.         'send',
  146.         'recv',
  147.         'sendto',
  148.         'recvfrom',
  149.         '__weakref__']
  150.     
  151.     def __init__(self, family = AF_INET, type = SOCK_STREAM, proto = 0, _sock = None):
  152.         if _sock is None:
  153.             _sock = _realsocket(family, type, proto)
  154.         
  155.         self._sock = _sock
  156.         self.send = self._sock.send
  157.         self.recv = self._sock.recv
  158.         self.sendto = self._sock.sendto
  159.         self.recvfrom = self._sock.recvfrom
  160.  
  161.     
  162.     def close(self):
  163.         self._sock = _closedsocket()
  164.         self.send = self.recv = self.sendto = self.recvfrom = self._sock._dummy
  165.  
  166.     close.__doc__ = _realsocket.close.__doc__
  167.     
  168.     def accept(self):
  169.         (sock, addr) = self._sock.accept()
  170.         return (_socketobject(_sock = sock), addr)
  171.  
  172.     accept.__doc__ = _realsocket.accept.__doc__
  173.     
  174.     def dup(self):
  175.         '''dup() -> socket object
  176.  
  177.         Return a new socket object connected to the same system resource.'''
  178.         return _socketobject(_sock = self._sock)
  179.  
  180.     
  181.     def makefile(self, mode = 'r', bufsize = -1):
  182.         '''makefile([mode[, bufsize]]) -> file object
  183.  
  184.         Return a regular file object corresponding to the socket.  The mode
  185.         and bufsize arguments are as for the built-in open() function.'''
  186.         return _fileobject(self._sock, mode, bufsize)
  187.  
  188.     _s = 'def %s(self, *args): return self._sock.%s(*args)\n\n%s.__doc__ = _realsocket.%s.__doc__\n'
  189.     for _m in _socketmethods:
  190.         exec _s % (_m, _m, _m, _m)
  191.     
  192.     del _m
  193.     del _s
  194.  
  195. socket = SocketType = _socketobject
  196.  
  197. class _fileobject(object):
  198.     '''Faux file object attached to a socket object.'''
  199.     default_bufsize = 8192
  200.     name = '<socket>'
  201.     __slots__ = [
  202.         'mode',
  203.         'bufsize',
  204.         'softspace',
  205.         '_sock',
  206.         '_rbufsize',
  207.         '_wbufsize',
  208.         '_rbuf',
  209.         '_wbuf']
  210.     
  211.     def __init__(self, sock, mode = 'rb', bufsize = -1):
  212.         self._sock = sock
  213.         self.mode = mode
  214.         if bufsize < 0:
  215.             bufsize = self.default_bufsize
  216.         
  217.         self.bufsize = bufsize
  218.         self.softspace = False
  219.         if bufsize == 0:
  220.             self._rbufsize = 1
  221.         elif bufsize == 1:
  222.             self._rbufsize = self.default_bufsize
  223.         else:
  224.             self._rbufsize = bufsize
  225.         self._wbufsize = bufsize
  226.         self._rbuf = ''
  227.         self._wbuf = []
  228.  
  229.     
  230.     def _getclosed(self):
  231.         return self._sock is None
  232.  
  233.     closed = property(_getclosed, doc = 'True if the file is closed')
  234.     
  235.     def close(self):
  236.         
  237.         try:
  238.             if self._sock:
  239.                 self.flush()
  240.         finally:
  241.             self._sock = None
  242.  
  243.  
  244.     
  245.     def __del__(self):
  246.         
  247.         try:
  248.             self.close()
  249.         except:
  250.             pass
  251.  
  252.  
  253.     
  254.     def flush(self):
  255.         if self._wbuf:
  256.             buffer = ''.join(self._wbuf)
  257.             self._wbuf = []
  258.             self._sock.sendall(buffer)
  259.         
  260.  
  261.     
  262.     def fileno(self):
  263.         return self._sock.fileno()
  264.  
  265.     
  266.     def write(self, data):
  267.         data = str(data)
  268.         if not data:
  269.             return None
  270.         
  271.         self._wbuf.append(data)
  272.         if not self._wbufsize == 0:
  273.             if self._wbufsize == 1 or '\n' in data or self._get_wbuf_len() >= self._wbufsize:
  274.                 self.flush()
  275.             
  276.  
  277.     
  278.     def writelines(self, list):
  279.         self._wbuf.extend(filter(None, map(str, list)))
  280.         if self._wbufsize <= 1 or self._get_wbuf_len() >= self._wbufsize:
  281.             self.flush()
  282.         
  283.  
  284.     
  285.     def _get_wbuf_len(self):
  286.         buf_len = 0
  287.         for x in self._wbuf:
  288.             buf_len += len(x)
  289.         
  290.         return buf_len
  291.  
  292.     
  293.     def read(self, size = -1):
  294.         data = self._rbuf
  295.         if size < 0:
  296.             buffers = []
  297.             if data:
  298.                 buffers.append(data)
  299.             
  300.             self._rbuf = ''
  301.             if self._rbufsize <= 1:
  302.                 recv_size = self.default_bufsize
  303.             else:
  304.                 recv_size = self._rbufsize
  305.             while True:
  306.                 data = self._sock.recv(recv_size)
  307.                 if not data:
  308.                     break
  309.                 
  310.                 buffers.append(data)
  311.             return ''.join(buffers)
  312.         else:
  313.             buf_len = len(data)
  314.             if buf_len >= size:
  315.                 self._rbuf = data[size:]
  316.                 return data[:size]
  317.             
  318.             buffers = []
  319.             if data:
  320.                 buffers.append(data)
  321.             
  322.             self._rbuf = ''
  323.             while True:
  324.                 left = size - buf_len
  325.                 recv_size = max(self._rbufsize, left)
  326.                 data = self._sock.recv(recv_size)
  327.                 if not data:
  328.                     break
  329.                 
  330.                 buffers.append(data)
  331.                 n = len(data)
  332.                 if n >= left:
  333.                     self._rbuf = data[left:]
  334.                     buffers[-1] = data[:left]
  335.                     break
  336.                 
  337.                 buf_len += n
  338.             return ''.join(buffers)
  339.  
  340.     
  341.     def readline(self, size = -1):
  342.         data = self._rbuf
  343.         if size < 0:
  344.             if self._rbufsize <= 1:
  345.                 if not data == '':
  346.                     raise AssertionError
  347.                 buffers = []
  348.                 recv = self._sock.recv
  349.                 while data != '\n':
  350.                     data = recv(1)
  351.                     if not data:
  352.                         break
  353.                     
  354.                     buffers.append(data)
  355.                 return ''.join(buffers)
  356.             
  357.             nl = data.find('\n')
  358.             if nl >= 0:
  359.                 nl += 1
  360.                 self._rbuf = data[nl:]
  361.                 return data[:nl]
  362.             
  363.             buffers = []
  364.             if data:
  365.                 buffers.append(data)
  366.             
  367.             self._rbuf = ''
  368.             while True:
  369.                 data = self._sock.recv(self._rbufsize)
  370.                 if not data:
  371.                     break
  372.                 
  373.                 buffers.append(data)
  374.                 nl = data.find('\n')
  375.                 if nl >= 0:
  376.                     nl += 1
  377.                     self._rbuf = data[nl:]
  378.                     buffers[-1] = data[:nl]
  379.                     break
  380.                     continue
  381.             return ''.join(buffers)
  382.         else:
  383.             nl = data.find('\n', 0, size)
  384.             if nl >= 0:
  385.                 nl += 1
  386.                 self._rbuf = data[nl:]
  387.                 return data[:nl]
  388.             
  389.             buf_len = len(data)
  390.             if buf_len >= size:
  391.                 self._rbuf = data[size:]
  392.                 return data[:size]
  393.             
  394.             buffers = []
  395.             if data:
  396.                 buffers.append(data)
  397.             
  398.             self._rbuf = ''
  399.             while True:
  400.                 data = self._sock.recv(self._rbufsize)
  401.                 if not data:
  402.                     break
  403.                 
  404.                 buffers.append(data)
  405.                 left = size - buf_len
  406.                 nl = data.find('\n', 0, left)
  407.                 if nl >= 0:
  408.                     nl += 1
  409.                     self._rbuf = data[nl:]
  410.                     buffers[-1] = data[:nl]
  411.                     break
  412.                 
  413.                 n = len(data)
  414.                 if n >= left:
  415.                     self._rbuf = data[left:]
  416.                     buffers[-1] = data[:left]
  417.                     break
  418.                 
  419.                 buf_len += n
  420.             return ''.join(buffers)
  421.  
  422.     
  423.     def readlines(self, sizehint = 0):
  424.         total = 0
  425.         list = []
  426.         while True:
  427.             line = self.readline()
  428.             if not line:
  429.                 break
  430.             
  431.             list.append(line)
  432.             total += len(line)
  433.             if sizehint and total >= sizehint:
  434.                 break
  435.                 continue
  436.         return list
  437.  
  438.     
  439.     def __iter__(self):
  440.         return self
  441.  
  442.     
  443.     def next(self):
  444.         line = self.readline()
  445.         if not line:
  446.             raise StopIteration
  447.         
  448.         return line
  449.  
  450.  
  451.